oslab2 进程通信与内存管理
进程的软中断通信
代码
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <signal.h>
int flag=0;
void inter_handler(int sig) {
// TODO
if (sig == SIGINT || sig == SIGQUIT || sig == SIGALRM){
flag = sig;
}
}
void waiting() {
// TODO
while(flag==0){
pause();
}
}
int main() {
// TODO: 五秒之后或接收到两个信号
signal(SIGINT, inter_handler);
signal(SIGQUIT, inter_handler);
signal(SIGALRM, inter_handler);
alarm(5);
pid_t pid1=-1, pid2=-1;
while (pid1 == -1)pid1=fork();//创建子进程1
if (pid1 > 0) {//子进程创建成功,当前为父进程
while (pid2 == -1)pid2=fork();//创建子进程2
if (pid2 > 0) {
// TODO: 父进程
// 等待信号
waiting();
printf("\n%d stop test\n",flag);
sleep(1);
kill(pid1, 16); // 向子进程1发送信号16
kill(pid2, 17); // 向子进程2发送信号17
wait(NULL);//等待子进程1
wait(NULL);//等待子进程2
printf("\nParent process is killed!!\n");
} else {
// TODO: 子进程 2
signal(17,inter_handler);
pause();//子进程2等待软中断信号17
printf("\n17 stop test\n");
printf("\nChild process2 is killed by parent!!\n");
return 0;
}
} else {//当前不是父进程
// TODO:子进程 1
signal(16,inter_handler);
pause();//子进程1等待软中断信号16
printf("\n16 stop test\n");
printf("\nChild process1 is killed by parent!!\n");
return 0;
}
return 0;
}
运行结果
5秒内按下 Ctrl+C

5秒内按 Ctrl+\

5秒内不进行任何操作

实验报告问题回答
- 你最初认为运行结果会怎么样?写出你猜测的结果。
预计父进程会创建两个子进程,收到信号后杀死它们,然后自己结束 - 实际的结果什么样?有什么特点?在接收不同中断前后有什么差别?请将 5 秒内中断和 5 秒后中断的运行结果截图,试对产生该现象的原因进行分析。
三种中断源都会触发相同流程;差别:只是触发信号编号不同,但处理逻辑一致 - 改为闹钟中断后,程序运行的结果是什么样子? 与之前有什么不同?
在5s内没有任何操作,然后程序会自动触发软中断,输出14 stop test,其余一致。区别是这种方式是自动的,不需要手动输入信号。 - kill 命令在程序中使用了几次?每次的作用是什么?执行后的现象是什么?
两次,分别向子进程1发送信号 16,向子进程2发送信号17。子进程收到后终止。 - 使用 kill 命令可以在进程的外部杀死进程。进程怎样能主动退出?这两种退出方式哪种更好一些?
主动退出的方法:
- return()
- exit()
exit()更好,其可以从任何进程退出,不影响父进程wait(),且退出前会执行刷新缓冲区等,更规范安全。
进程的管道通信
代码
/*管道通信实验程序 */
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
int pid1, pid2; // 定义两个进程变量
int main()
{
int fd[2];
char InPipe[4000]; // 定义读缓冲区
char c1 ='1', c2 ='2';
pipe(fd); // 创建管道
while ((pid1 = fork()) == -1); // 如果进程 1 创建不成功,则空循环
if (pid1 == 0)
{//子进程1
lockf(fd[1],1,0); // 锁定管道
for(int i = 0 ; i < 2000; i++)
write(fd[1], &c1, 1);
sleep(5);
lockf(fd[1],0,0); // 解除管道的锁定
exit(0); // 结束进程 1
}
else
{//父进程
while ((pid2 = fork()) == -1); // 若进程 2 创建不成功,则空循环
if (pid2 == 0)
{//子进程2
lockf(fd[1], 1, 0);
for(int i = 0 ; i < 2000; i++)
write(fd[1], &c2, 1);
sleep(5);
lockf(fd[1], 0, 0);
exit(0);
}
else
{//父进程
wait(NULL); // 等待子进程 1 结束
wait(NULL); // 等待子进程 2 结束
int end = read(fd[0], InPipe, 4000);
InPipe[end] = '\0'; // 加字符串结束符
printf("%s\n", InPipe); // 显示读出的数据
exit(0); // 父进程结束
}
}
}
运行结果、
有锁

无锁

实验报告
- 你最初认为运行结果会怎么样?
输出1111.....11111.....2222.....22222 - 实际的结果什么样?有什么特点?试对产生该现象的原因进行分析。
在不加锁的情况下,输出就是1与2交叉的。加锁的情况下则不存在交叉,分别输出2000个1和2000个2。对管道写端加互斥锁,使得两个子进程不能同时写入管道。 - 实验中管道通信是怎样实现同步与互斥的?如果不控制同步与互斥会发生什么后果?
- 同步:read()在管道空的时候会阻塞,直到有数据,write()在管道满的时候会阻塞,直到有空间。
- 互斥:通过加
lockf(fd[1],0,0);实现互斥。
如果不控制,则可能会出现数据错误与混乱。
页面的置换
代码
#include <stdio.h>
#include <stdlib.h>
#define MAX_REF 1000 // 最大引用串长度
#define MAX_MEM 20 // 最大物理块数
int ref[MAX_REF]; // 页面引用串
int ref_len; // 引用串长度
int mem_size; // 物理块数
void debug_print_mem(int mem[], int mem_size) {
printf("[ ");
for (int i = 0; i < mem_size; i++) {
if (mem[i] == -1) printf("_ ");
else printf("%d ", mem[i]);
}
printf("]");
}
void FIFO()
{
int mem[MAX_MEM], front = 0;
int faults = 0;
for (int i = 0; i < mem_size; i++)
mem[i] = -1;//初始化
for (int i = 0; i < ref_len; i++) {
int page = ref[i];
int hit = 0;
for (int j = 0; j < mem_size; j++) {
if (mem[j] == page) {
hit = 1;
break;
}
}
if (!hit) { // 缺页
faults++;
mem[front] = page;
front = (front + 1) % mem_size;
debug_print_mem(mem, mem_size);
printf("\n");
}
}
printf("\nFIFO 总缺页次数:%d,缺页率:%.2f%%\n",
faults, faults * 100.0 / ref_len);
}
void LRU()
{
int mem[MAX_MEM], last_used[MAX_MEM];
int faults = 0;
for (int i = 0; i < mem_size; i++) {
mem[i] = -1;
last_used[i] = -1;
}
for (int t = 0; t < ref_len; t++) {
int page = ref[t];
int hit = 0;
for (int j = 0; j < mem_size; j++) {
if (mem[j] == page) {
hit = 1;
last_used[j] = t;
break;
}
}
if (!hit) { // 缺页
faults++;
printf("缺页 -> 调入页面 %d : ", page);
int victim = 0;
for (int j = 1; j < mem_size; j++)
if (last_used[j] < last_used[victim])
victim = j;
mem[victim] = page;
last_used[victim] = t;
debug_print_mem(mem, mem_size);
printf("\n");
}
}
printf("\nLRU 总缺页次数:%d,缺页率:%.2f%%\n",
faults, faults * 100.0 / ref_len);
}
void gen_random_ref()
{
printf("请输入引用串长度:");
scanf("%d", &ref_len);
for (int i = 0; i < ref_len; i++)
ref[i] = rand() % 10; // 0~9 的页面号
printf("随机生成的引用串:\n");
for (int i = 0; i < ref_len; i++)
printf("%d ", ref[i]);
printf("\n");
}
void input_ref()
{
printf("请输入引用串长度:");
scanf("%d", &ref_len);
printf("逐个输入页面号:\n");
for (int i = 0; i < ref_len; i++) {
scanf("%d", &ref[i]);
}
}
int main()
{
int choice;
mem_size = 5;
printf("\n引用串生成方式:\n1. 随机生成\n2. 手动输入\n选择:");
scanf("%d", &choice);
if (choice == 1) gen_random_ref();
else input_ref();
printf("\n选择页面置换算法:\n1. FIFO\n2. LRU\n选择:");
scanf("%d", &choice);
if (choice == 1) FIFO();
else LRU();
return 0;
}
运行结果
FIFO

LRU

Belady
物理块数3:

物理块数4:

实验报告
- 从实现和性能方面,比较分析 FIFO 和 LRU 算法。
FIFO:先进先出,一般使用队列,不体现局部性原理,比较简单,可能会出现Belady异常。
LRU:优先替换长时间未使用的,一般增加带时间戳的数据,体现局部性原理,使用过的数据在一定时间内或一定位置内可能会被多次使用,较复杂。由于局部性原理,缺页率一般会更低。 - LRU 算法是基于程序的局部性原理而提出的算法,你模拟实现的 LRU 算法有没有体现出该特点?如果有,是如何实现的?
每次访问页面时都对其时间戳进行更新,如果缺页,则找到时间戳最久的进行替换,这样保证最近使用过的页面不会被替换。 - 在设计内存管理程序时,应如何提高内存利用率。
- 采用LRU等算法
- 预先对引用块进行排序或优化
- 增加物理块数量